﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SGT_DAL._STG_DALTableAdapters;
using SGT_DAL;

namespace SGT_ON
{
    /// <summary>
    /// Clase utilizada para la presentación y propiedades derivadas.
    /// </summary>
    public partial class ONInterrupcion
    {
        #region Propiedades derivadas
        /// <summary>
        /// Devuelve la cantidad de horas totales
        /// </summary>
        public string CantidadDeHoras
        {
            get
            {
                if ((FechaHoraFin.HasValue == false)
                    || (FechaHoraFin <= Parametros.FechaMinima)
                    || (FechaHoraInicio <= Parametros.FechaMinima))
                    return "";

                TimeSpan _ts = FechaHoraFin.Value - FechaHoraInicio;
                if (_ts.TotalHours <= 0)
                    return "";

                return _ts.TotalHours.ToString("#0.00");
            }
        }
        #endregion

        #region propiedades como string
        public string FechaHoraInicioString
        {
            get
            {
                return FechaHoraInicio.ToString("dd/MM/yyyy HH:mm");
            }
        }
        public string FechaHoraFinString
        {
            get
            {
                if (FechaHoraFin.HasValue == true)
                    return FechaHoraFin.Value.ToString("dd/MM/yyyy HH:mm");
                else
                    return "";
            }
        }
        #endregion
    }
    /// <summary>
    /// Clase base con la lógica de negocio
    /// </summary>
    [System.ComponentModel.DataObject]
    public partial class ONInterrupcion
    {
        #region Atributos
        protected int _id;
        protected DateTime _fechaHoraInicio;
        protected DateTime? _fechaHoraFin;
        protected string _motivo;
        protected int _tareaLineaDeTiempoId;
        
        //Objetos asociados
        #endregion

        #region Propiedades
        public int ID
        {
            get
            {
                return _id;
            }
            set
            {
                _id = value;
            }
        }
        public DateTime FechaHoraInicio
        {
            get
            {
                return _fechaHoraInicio;
            }
            set
            {
                _fechaHoraInicio = value;
            }
        }
        public DateTime? FechaHoraFin
        {
            get
            {
                return _fechaHoraFin;
            }
            set
            {
                _fechaHoraFin = value;
            }
        }
        public string Motivo
        {
            get
            {
                return _motivo;
            }
            set
            {
                _motivo = value;
            }
        }
        public int TareaLineaDeTiempoId
        {
            get
            {
                return _tareaLineaDeTiempoId;
            }
            set
            {
                _tareaLineaDeTiempoId = value;
            }
        }

        //Objetos asociados
        #endregion

        #region Interfase DAL
        //objeto de la capa DAL
        private static InterrupcionTableAdapter _interrupcionAD;
        protected static InterrupcionTableAdapter Adaptador
        {
            get
            {
                if (_interrupcionAD == null)
                    _interrupcionAD = new InterrupcionTableAdapter();

                return _interrupcionAD;
            }
        }
        protected static ONInterrupcion ObtenerPorID(int pID)
        {   
            _STG_DAL.InterrupcionDataTable _dt;

            _dt = Adaptador.ObtenerPorId(pID);

            // si tiene algo,
            if (_dt.Rows.Count > 0)
                return AsignarRowAObjeto((_STG_DAL.InterrupcionRow)_dt.Rows[0]);

            return null;
        }
        protected static ONInterrupcion AsignarRowAObjeto(_STG_DAL.InterrupcionRow pRow)
        {
            ONInterrupcion _interrupcion = new ONInterrupcion();
            if (pRow != null)
            {
                _interrupcion = new ONInterrupcion();

                _interrupcion.ID = pRow.ID;
                
                _interrupcion.FechaHoraInicio = pRow.FechaHoraInicio;
                
                if (pRow.IsFechaHoraFinNull() == true)
                    _interrupcion.FechaHoraFin = null;
                else
                    _interrupcion.FechaHoraFin = pRow.FechaHoraFin;
                
                _interrupcion.Motivo = pRow.Motivo;

                _interrupcion.TareaLineaDeTiempoId = pRow.TareaLineaDeTiempoId;
            }
            return _interrupcion;
        }
        protected ONInterrupcion InsertarDAL(DateTime pFechaHoraInicio, DateTime? pFechaHoraFin, string pMotivo, int pTareaLineaDeTiempoId)
        {
            ID = int.Parse(Adaptador.Insertar(pFechaHoraInicio, pFechaHoraFin, pMotivo, pTareaLineaDeTiempoId).ToString());
            return this;
        }
        protected bool ActualizarDAL(DateTime pFechaHoraInicio, DateTime? pFechaHoraFin, string pMotivo, int pTareaLineaDeTiempoId, int pID)
        {
            if (0 < Adaptador.Actualizar(pFechaHoraInicio, pFechaHoraFin, pMotivo, pTareaLineaDeTiempoId, pID))
                return true;
            else
                return false;
        }
        public static void EliminarDAL(int pId)
        {
            if (Adaptador.Eliminar(pId) == 0)
                throw new ArgumentException("La interrupción no existe en la base de datos.");
        }
        protected static ONInterrupcionColeccion AsignarInterrupcionTableAdapterAInterrupcionColeccion(_STG_DAL.InterrupcionDataTable pDataTable)
        {
            ONInterrupcionColeccion _interrupciones = new ONInterrupcionColeccion();
            ONInterrupcion _interrupcion;

            if ((pDataTable != null)
                && (pDataTable.Rows.Count > 0))
            {
                foreach (_STG_DAL.InterrupcionRow _row in pDataTable.Rows)
                {
                    _interrupcion = AsignarRowAObjeto(_row);
                    if (_interrupcion != null)
                        _interrupciones.Add(_interrupcion);
                }
            }
            return _interrupciones;
        }
        public static ONInterrupcionColeccion ObtenerInterrupcionesDeTareaLineaDeTiempoDAL(int pTareaLineaDeTiempoId)
        {
            return AsignarInterrupcionTableAdapterAInterrupcionColeccion(Adaptador.ObtenerInterrupcionesDeTareaLineaDeTiempo(pTareaLineaDeTiempoId));
        }

        #endregion

        #region Métodos
        public ONInterrupcion()
        {
            AsignarValoresIniciales();
        }

        public void AsignarValoresIniciales()
        {
            _id = -1;
            FechaHoraInicio = Parametros.FechaMinima;
            FechaHoraFin = null;
            Motivo = "";
            TareaLineaDeTiempoId = -1;
        }

        public static ONInterrupcion CrearInterrupcion()
        {
            ONInterrupcion _interrupcion = new ONInterrupcion();
            return _interrupcion;
        }
        public static ONInterrupcion CrearInterrupcion(int pID)
        {
            ONInterrupcion _interrupcion = ObtenerPorID(pID);
            return _interrupcion;
        }
        public ONInterrupcion Insertar()
        {
            return InsertarDAL(FechaHoraInicio, FechaHoraFin, Motivo, TareaLineaDeTiempoId);
        }
        public bool Actualizar()
        {
            return ActualizarDAL(FechaHoraInicio, FechaHoraFin, Motivo, TareaLineaDeTiempoId, ID);
        }
        #endregion

        #region Metodos para datasource
        public void Actualizar(ONInterrupcion pInterrupcion)
        {
            if (pInterrupcion != null)
                pInterrupcion.Actualizar();
        }
        public ONInterrupcion Insertar(ONInterrupcion pInterrupcion)
        {
            if (pInterrupcion != null)
                return pInterrupcion.Insertar();
            return null;
        }
        public void Eliminar(int pInterrupcionId)
        {

            ONInterrupcion.EliminarDAL(pInterrupcionId);
        }
        #endregion
    }
    [System.ComponentModel.DataObject]
    public class ONInterrupcionColeccion : System.Collections.CollectionBase
    {
        public void Add(ONInterrupcion pInterrupcion)
        {
            this.List.Add(pInterrupcion);
        }
        public void AddUnico(ONInterrupcion pInterrupcion)
        {
            foreach (ONInterrupcion _interrupcion in this)
                if (pInterrupcion.ID == _interrupcion.ID)
                    return;
            this.List.Add(pInterrupcion);
        }
        public void Remove(int index)
        {
            if (index <= Count - 1 || index >= 0)
            {
                this.List.RemoveAt(index);
            }
            else
            {
                throw new System.ArgumentException("Fuera de rango", "original");
            }
        }
        public void Remove(ONInterrupcion pInterrupcion)
        {
            for (int i = 0; i < this.Count; i++)
            {
                if (this[i].ID == pInterrupcion.ID)
                {
                    Remove(i);
                    return;
                }

            }
        }
        public ONInterrupcion this[int index]
        {
            get { return ((ONInterrupcion)(this.List[index])); }
            set { this.List[index] = value; }
        }
        public void ActualizarInterrupciones(ONInterrupcionColeccion pInterrupciones)
        {
            foreach (ONInterrupcion _interrupcion in pInterrupciones)
            {
                _interrupcion.Actualizar();
            }
        }
        public void ActualizarInterrupcion(ONInterrupcion pInterrupcion)
        {
            pInterrupcion.Actualizar();
        }

        #region Metodos de colección
        
        #endregion
        #region Para datasource
        
        #endregion
    }
}
